package com.itzjc.service.impl;

import com.itzjc.dao.ProjectMapper;
import com.itzjc.dao2.ProjectMapper2;
import com.itzjc.domain.entity.*;
import com.itzjc.domain.pojo.*;
import com.itzjc.service.ProjectService;
import com.itzjc.utils.JWTUtils;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * TODO
 *
 * @className: ProjectServiceImpl
 * @date: 2021-06-10 21:55
 **/
@Service
public class ProjectServiceImpl implements ProjectService {
    @Autowired(required = false)
    private ProjectMapper projectMapper;
    @Autowired(required = false)
    private ProjectMapper2 projectMapper2;

    @Override
    public List<ProjectInfo> getProjectByToken(Integer userId) {

        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就按照userID获取
        Integer status=projectMapper.findStatusById(userId);
        //这里获取以后还有文件编号没有获取到，这也是需要获取的
        if (status==2||status==1){
            //这里说明不是普通用户，就获取全部
            //获取以后需要做一件事情，就是把这个结果中的状态赋予中文

            List<ProjectInfo> projectInfos = projectMapper.findAll();
            setStringForStageAndStatus(projectInfos);
            return projectInfos;

        }else if (status ==3){//这里说明是普通用户，就获取特定的
            List<ProjectInfo> projectInfos2 = projectMapper.findById(userId);
            setStringForStageAndStatus(projectInfos2);

            //然后这里把文件名称查进去很浪费时间就没有这么做
            return projectInfos2;}
            //如果是4说明被冻结，不查询
        return null;

    }

    private void setStringForStageAndStatus(List<ProjectInfo> projectInfos2) {
        for (ProjectInfo projectInfo : projectInfos2) {

            switch (projectInfo.getStage()) {
                case 0:
                    projectInfo.setStageString("未开始");
                    break;
                case 1:
                    projectInfo.setStageString("模型进场");
                    break;
                case 2:
                    projectInfo.setStageString("完成未退场");
                    break;
                case 3:
                    projectInfo.setStageString("完成并退场");
                    break;
                default:
                    projectInfo.setStatusString("系统异常");
            }
            switch (projectInfo.getStatus()){
                case 0:
                    projectInfo.setStatusString("未审核");
                    break;
                case 1:
                    projectInfo.setStatusString("审核通过");
                    break;
                case 2:
                    projectInfo.setStatusString("审核未通过");
                    break;
                case 3:
                    projectInfo.setStatusString("重新审核中");
                    break;
                default:
                    projectInfo.setStatusString("系统异常");

            }
        }
    }

    /**
     *
     * @param requestProject
     * @return:
     **/

    @Override
    @Transactional(transactionManager = "test1TransactionManager")//事务控制
    public String createProjectById(RequestProject requestProject) {
        //把项目表添加完成，需要返回添加项目成果的id，交给关系表构建
        ProjectInfo projectInfo = new ProjectInfo();
        ProjectFileInfo projectFileInfo = new ProjectFileInfo();

        //写入projectInfo，传入数据库
        projectInfo.setProjectName(requestProject.getProjectName());
        projectInfo.setStatus(0);
        projectInfo.setCreateTime(new Date());
        projectInfo.setStage(0);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        try {
            projectInfo.setStartTime(sdf.parse(requestProject.getStartTime()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        try {
            projectInfo.setEndTime(sdf.parse(requestProject.getEndTime()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        projectInfo.setDescription(requestProject.getDescription());
        projectInfo.setPhone(requestProject.getPhone());
        projectInfo.setOwner(requestProject.getOwner());
        projectInfo.setReason(requestProject.getReason());

        //前端还传来了两个关联文件的信息，这里需要处理一下，写入到projectFileInfo，传入数据库
        projectFileInfo.setAgreementURL(requestProject.getAgreementURL());
        projectFileInfo.setMethodURL(requestProject.getMethodURL());
        projectFileInfo.setStatus(1);//默认设置为1，1为关联，2为取消关联变成历史
        projectFileInfo.setCreateTime(new Date());


        //开始是没有创建的项目的id的，只有创建的方法完成以后，封装的projectInfo才是有id的,所以一个是请求的id，一个是查出来的id
        //原本的id都在token中，所以拿出来解析一下
        String token = requestProject.getToken();
        Claims claims = JWTUtils.checkJWT(token);
        if (null == claims) {
            return null;
        }
        Integer uid = (Integer) claims.get("id");


        //解析完毕以后，就算不登录也没有问题了,但是要判断一下有没有这个项目
        ProjectInfo projectInfo1 = projectMapper.beforeCreateProject(uid, projectInfo.getProjectName());
        //解析完毕，判断不是null以后才是添加关系表
        if (null == projectInfo1) {
            //插入到表格的语句不能写在前面，因为刚才发现，没有token的时候都创建成功了

            //而且，添加创建的操作一定要放到里面来，不然重复添加还是会在总表中添加的
            //然后这里插入数据的时候，自动有查询生成ID的语句的，自动封装的，所以直接获取就行了
            projectMapper.createProject(projectInfo);
            Integer pjId = projectInfo.getId();
            //添加用户-项目关系表
            projectMapper.createProjectById(uid, pjId);

            projectFileInfo.setPjid(pjId);
            //写入文件的配套信息，文件配套写完以后就有一个id，获取这个id，这个id就可以用来和下面的匹配
            projectMapper.createProjectFile(projectFileInfo);
            Integer fileId = projectFileInfo.getId();
            //添加项目-文件关系表
            projectMapper.createProjectVSFile(fileId, pjId);

            //都成功以后就可以返回名称了
            String name = requestProject.getProjectName();
            return name;
        } else {
            //如果查出了重复项目就返回null，主要是返回300的状态码，前端就是根据这个状态码输出对应的语句的
            return null;
        }

    }

    @Override
    @Transactional(transactionManager = "test1TransactionManager")
    public void deleteProjectByToken(Integer userId, Integer projectId) {
        //项目表中删除
        projectMapper.deleteProjectByToken(projectId);
        //关系表中删除
        projectMapper.deleteProjectUzserByToken(userId, projectId);
    }

    /**
    *   查询正在申请的项目，所以要绑定文件信息
    * @param userId
    * @return:
    **/

    @Override
    public List<ProjectInfo> getAuditProjectByToken(Integer userId) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞，不要返回任何东西
        Integer status=projectMapper.findStatusById(userId);
        //这里就是直接获取全部的有效文件文件还有有效的用户名列表
        List<FileInfo> fileInfos=projectMapper.findAllFiles();
        List<User>  users=projectMapper.findAllUserInfo();
        List<RelationUserAndProject> relationUserAndProjects=projectMapper.findAllRelationUserAndProject();
        //获取CDN前缀
        String cdnDomain=projectMapper.getCdn();

        //这里获取以后还有文件编号没有获取到，这也是需要获取的
        if (status==2) {
            List<ProjectInfo> projectInfos = projectMapper.findAllAuditingProject();
            if (null!=users&&null!=relationUserAndProjects&&null !=fileInfos) {
                for (ProjectInfo projectInfo : projectInfos) {
                    for (FileInfo fileInfo : fileInfos) {
                        if(fileInfo.getPjid()==projectInfo.getId()){
                            projectInfo.setAgreementURL(cdnDomain+fileInfo.getAgreementURL());
                            projectInfo.setMethodURL(cdnDomain+fileInfo.getMethodURL());
                        }
                    }
                    //遍历写入姓名
                    for (RelationUserAndProject relationUserAndProject : relationUserAndProjects) {
                        if (projectInfo.getId()==relationUserAndProject.getPjid()) {
                            for (User user : users) {
                                if (user.getId()==relationUserAndProject.getUid()) {
                                    projectInfo.setUserName(user.getUserName());
                                }
                            }
                        }
                    }


                }

            }
            setStringForStageAndStatus(projectInfos);
            return projectInfos;
        }
        return null;
    }

    /**
    *   查询已经审核通过的项目，所以暂时不用管文件信息，可以提速，如果需要绑定文件，就从上面的复制就行了
    * @param userId
    * @return:
    **/

    @Override
    public List<ProjectInfo> getAuditedProjectByToken(Integer userId) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞，不要返回任何东西
        Integer status=projectMapper.findStatusById(userId);
        //这里就是直接获取全部的有效的用户名列表
        List<User>  users=projectMapper.findAllUserInfo();
        List<RelationUserAndProject> relationUserAndProjects=projectMapper.findAllRelationUserAndProject();

        //这里获取以后还有文件编号没有获取到，这也是需要获取的
        if (status==2 || status==1) {
            //需要获取用户信息之类的，还要获取文件信息之类的
            List<ProjectInfo> projectInfos = projectMapper.findAllAuditedProject();
            if (0!=users.size()&&0!=relationUserAndProjects.size()){
                for (ProjectInfo projectInfo : projectInfos) {
                    //遍历写入姓名
                    for (RelationUserAndProject relationUserAndProject : relationUserAndProjects) {
                        if (projectInfo.getId()==relationUserAndProject.getPjid()) {
                            for (User user : users) {
                                if (user.getId()==relationUserAndProject.getUid()) {
                                    projectInfo.setUserName(user.getUserName());
                                }
                            }
                        }
                    }
                }
            }

            setStringForStageAndStatus(projectInfos);
            return projectInfos;
        }
        return null;

    }

    @Override
    public List<ProjectInfo> getAuthorizingProjectByToken(Integer userId) {
        return null;
    }

    @Override
    public List<ProjectInfo> getAuthorizedProjectByToken(Integer userId) {
        return null;
    }

    @Override
    public CurrentProjectInfo getProjectInfoByTokenAndId(Integer userId, Integer projectId) {

        CurrentProjectInfo currentProjectInfo = projectMapper.getProjectById(projectId);
        switch (currentProjectInfo.getStage()) {
            case 0:
                currentProjectInfo.setStageString("未开始");
                break;
            case 1:
                currentProjectInfo.setStageString("完成但器材未退场");
                break;
            case 2:
                currentProjectInfo.setStageString("完成且退场");
                break;
            default:
                currentProjectInfo.setStatusString("系统异常");
        }
        switch (currentProjectInfo.getStatus()){
            case 0:
                currentProjectInfo.setStatusString("未审核");
                break;
            case 1:
                currentProjectInfo.setStatusString("审核通过");
                break;
            case 2:
                currentProjectInfo.setStatusString("审核未通过");
                break;
            case 3:
                currentProjectInfo.setStatusString("重新审核中");
                break;
            default:
                currentProjectInfo.setStatusString("系统异常");

        }

        //反查文件信息
       FileInfo fileInfo= projectMapper.getMethodURLAndAgreementURLById(projectId);
        //反查用户信息
        User user=projectMapper.getUserInfoById(projectId);


        currentProjectInfo.setAgreementURL(fileInfo.getAgreementURL());
        currentProjectInfo.setMethodURL(fileInfo.getMethodURL());
        currentProjectInfo.setId(projectId);
        currentProjectInfo.setPlaceBelong(user.getPlaceBelong());
        currentProjectInfo.setUid(user.getId());
        currentProjectInfo.setUserName(user.getUserName());

        currentProjectInfo.setPhone(user.getPhone());


        return currentProjectInfo;
    }



    @Override
    public String updateProjectImg(RequestImage requestImage) {
        Integer projectId = Integer.valueOf(requestImage.getProjectId());
        Integer uid = Integer.valueOf(requestImage.getUid());
        Integer count = projectMapper.exitProject(uid, projectId);
        if (0 == count) {
            return null;
        }

        String img = requestImage.getImgName();
        projectMapper.updateProjectImg(img, projectId);
        return "更新成功";
    }

   /**
   *  这个就是后期修改项目中的某些信息用到的方法
   * @param requestUpdateAllProject
   * @return:
   **/

    @Override
    @Transactional(transactionManager = "test1TransactionManager")//事务控制
    public void updateWholeProject(RequestUpdateAllProject requestUpdateAllProject) {
        //没必要查出原来的，修改了哪些就更新哪些就行了，没有修改的字段就不动就行了
        ProjectInfo projectInfo = new ProjectInfo();
        ProjectFileInfo projectFileInfo = new ProjectFileInfo();

        projectFileInfo.setMethodURL(requestUpdateAllProject.getMethodURL());
        projectFileInfo.setAgreementURL(requestUpdateAllProject.getAgreementURL());
        projectFileInfo.setStatus(1);//默认设置为1，1为关联，2为取消关联变成历史
        projectFileInfo.setCreateTime(new Date());

        projectInfo.setReason(requestUpdateAllProject.getReason());
        projectInfo.setDescription(requestUpdateAllProject.getDescription());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        try {
            projectInfo.setStartTime(sdf.parse(requestUpdateAllProject.getStartTime()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        try {
            projectInfo.setEndTime(sdf.parse(requestUpdateAllProject.getEndTime()));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Integer pjId=Integer.valueOf(requestUpdateAllProject.getProjectID());
        projectInfo.setId(pjId);

        //更新时先将原本关联的两个文件状态变成重新提交的状态，所以此时要设置一下状态,把原本的status为1的记录改成2
        projectMapper.updateProjectFileStatus(pjId);

        //上面是改变状态，这里相当于重新写一个文件进去，原本的只是改变了状态
        projectFileInfo.setPjid(pjId);
        //写入文件的配套信息，文件配套写完以后就返回一个id，获取这个id，这个id就可以用来和下面的匹配
        projectMapper.createProjectFile(projectFileInfo);
        Integer fileId = projectFileInfo.getId();
        //添加项目-文件关系表
        projectMapper.createProjectVSFile(fileId, pjId);


        //此处项目和文件是分开的，文件是重新创建，然后原本的状态变成3，项目的几个信息就更新就行了
        projectMapper.updateWholeProject(projectInfo);

    }


    /**
     * 这个方法主要是后期修改文件所用到的方法,【暂时没有启用】
     * @param
     * @return:
     **/
    @Override
    public String updateProjectModule(RequestModule requestModule) {
        Integer projectId = Integer.valueOf(requestModule.getProjectId());
        Integer uid = Integer.valueOf(requestModule.getUid());
        Integer count = projectMapper.exitProject(uid, projectId);
        if (0 == count) {
            return null;
        }
        String obj = requestModule.getObjName();
        String mtl = requestModule.getMtlName();

        projectMapper.updateProjectModule(obj, mtl, projectId);
        return "更新成功";
    }

    @Override
    public List<BigInteger> findByIdForSecondSource(int id) {
        return projectMapper2.findByIdForSecondSource(id);
    }

    @Override
    public void okForThisProject(Integer projectId) {
        //修改状态码status就可以了
        projectMapper.okForThisProject(projectId);
    }

    @Override
    public String rejectCurrentProject(RequestRejectCurrentProject requestRejectCurrentProject) {
        //这里就是根据ID修改项目的状态码，然后更新理由就可以了
        Integer projectId=requestRejectCurrentProject.getCurrentProjectId();
        String reason=requestRejectCurrentProject.getReason();
        projectMapper.rejectCurrentProject(projectId,reason);
        return "ok";
    }

    /**
    * 修改项目的状态的
    * @param requestSureCurrentProjectStage
    * @return:
    **/

    @Override
    public String sureCurrentProjectStage(RequestSureCurrentProjectStage requestSureCurrentProjectStage) {
        //根据项目的ID修改项目的stage值就行了
        Integer stage= Integer.valueOf(requestSureCurrentProjectStage.getStage());
        Integer projectId=requestSureCurrentProjectStage.getCurrentProjectId();
        projectMapper.sureCurrentProjectStage(projectId,stage);
        return "ok";
    }

    @Override
    public List<User> getBlockedUsers(Integer userId) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞，不要返回任何东西
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是查询黑名单用户，也就是status为4的用户
           List<User> users= projectMapper.getBlockedUsers();
           return users;
        }
        return null;
    }

    @Override
    public List<User> getUnBlockedUsers(Integer userId) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞，不要返回任何东西
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是查询黑名单用户，也就是status为3的用户
            List<User> users= projectMapper.getUnBlockedUsers();
            return users;
        }
        return null;
    }

    @Override
    public void recoverUser(Integer userId, Integer uIdForUser) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是移出黑名单的用户，也就是status为4的用户变成3
            projectMapper.recoverUser(uIdForUser);

        }


    }

    @Override
    public void moveOutUser(Integer userId, Integer uIdForUser) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是查询黑名单用户，也就是status为3的用户变成4
            projectMapper.moveOutUser(uIdForUser);

        }


    }

    @Override
    public List<ProjectInfo> searchProjectInfoByTokenAndString(Integer userId, String word) {
        //这里加一个判断，如果这个ID的status是2就获取全部，并且查询的时候先用户名称模糊查询
        //先用户名称模糊查询看能不能查到id，不能查到再启用模糊查询，如果查到了就直接返回
        //如果用户的status是3就模糊查询的时候就直接走后面的项目表的模糊查询
        Integer status=projectMapper.findStatusById(userId);

        if (status==2||status==1){
            //这里说明不是普通用户，就获取全部
            //此时是第一步，去用户表中查询，还要做一个很无语的事情，就是把查到的教师名称写入，这里还是需要分步
            //因为老师有可能有名字重合，所以还是需要把步骤分开
            //这里就是模糊查询用户表从而获取全部的有效的用户名列表
            //然后这里还有一点，管理员查询的时候应该查询的是审核通过的项目
            List<User>  users =projectMapper.searchAllUserInfo(word);
            List<RelationUserAndProject> relationUserAndProjects=projectMapper.findAllRelationUserAndProject();
            //如果是用户查出了东西就走用户这条路,这里也有漏洞，如果这个用户的名字里有项目名称呢？
            //应该还要加一个判断，判断最后查出来的东西是否是有数据的，如果使用用户这条路没有查出来数据还要走一遍模糊查询
            if (0!= users.size()) {
                List<ProjectInfo> projectInfos = projectMapper.searchAllInTableUsers(word);
                //给每条写入对应的用户名
                    if (null!=users&&null!=relationUserAndProjects){
                        for (ProjectInfo projectInfo : projectInfos) {
                            //遍历写入姓名
                            for (RelationUserAndProject relationUserAndProject : relationUserAndProjects) {
                                if (projectInfo.getId() == relationUserAndProject.getPjid()) {
                                    for (User user : users) {
                                        if (user.getId() == relationUserAndProject.getUid()) {
                                            projectInfo.setUserName(user.getUserName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                if (0==projectInfos.size()) {
                    //如果用户这里查出了用户，但是没有项目，此时就走模糊查询查项目
                    List<User>  users2=projectMapper.findAllUserInfo();
                    List<ProjectInfo> projectInfos1 = projectMapper.searchAllInTableProjectInfo(word);
                    if (0 !=users2.size()&&0!=relationUserAndProjects.size()){
                        for (ProjectInfo projectInfo : projectInfos1) {
                            //遍历姓名
                            for (RelationUserAndProject relationUserAndProject : relationUserAndProjects) {
                                if (projectInfo.getId() == relationUserAndProject.getPjid()) {
                                    for (User user : users2) {
                                        if (user.getId() == relationUserAndProject.getUid()) {
                                            projectInfo.setUserName(user.getUserName());
                                        }
                                    }
                                }
                            }

                        }
                    }
                    setStringForStageAndStatus(projectInfos1);
                    return projectInfos1;
                }else {
                    setStringForStageAndStatus(projectInfos);
                    return projectInfos;
                }

            }
            else {
                //如果用户没有查出来，就直接在项目表中启用模糊查询,此时还是设计添加用户名的问题，所以查出数据是一方面，还需要添加用户
                //这里就是获取全部的用户数据了
                List<User>  users2=projectMapper.findAllUserInfo();
                //接着是去查询，然后把名称对应写进去
                List<ProjectInfo> projectInfos=projectMapper.searchAllInTableProjectInfo(word);
                if (0 !=users2.size()&&0!=relationUserAndProjects.size()){
                    for (ProjectInfo projectInfo : projectInfos) {
                        //遍历姓名
                        for (RelationUserAndProject relationUserAndProject : relationUserAndProjects) {
                            if (projectInfo.getId() == relationUserAndProject.getPjid()) {
                                for (User user : users2) {
                                    if (user.getId() == relationUserAndProject.getUid()) {
                                        projectInfo.setUserName(user.getUserName());
                                    }
                                }
                            }
                        }
                    }

                }
                setStringForStageAndStatus(projectInfos);
                return projectInfos;
            }

        }else if (status ==3){
            //这里说明是普通用户，就获取特定的,不用管用户名称问题了，此时搜索主要就是在项目表中搜索了
            List<ProjectInfo> projectInfos = projectMapper.searchAllInTableProjectInfoById(userId,word);
            setStringForStageAndStatus(projectInfos);

            //然后这里把文件名称查进去很浪费时间就没有这么做
            return projectInfos;}
        //如果是4说明被冻结，不查询
        return null;
    }

    @Override
    public List<User> searchUsersByTokenAndString(Integer userId, String word) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞，不要返回任何东西
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是按照关键字搜索，关键字就是用户的名称
            List<User> users= projectMapper.searchAllUserInfo(word);
            return users;
        }
        return null;
    }

    @Override
    public List<FileFromCenter> getFilesFromCenter(Integer userId) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就按照userID获取
        Integer status=projectMapper.findStatusById(userId);
        //这里获取以后还有文件编号没有获取到，这也是需要获取的
        if (status==4){
            //说明没有权限，不返回任何东西
            return null;
        }

        List<FileFromCenter> fileFromCenter = projectMapper.findAllFileFromCenter();
        return fileFromCenter;

    }

    @Override
    @Transactional(transactionManager = "test1TransactionManager")//事务控制
    public String uploadFileToCenter(RequestFileCenterCreator requestFileCenterCreator) {
        //拿到名称和地址就行了，然后手动写入domain和创建时间，还有状态
        FileFromCenter fileFromCenter = new FileFromCenter();
        fileFromCenter.setCreateTime(new Date());
        fileFromCenter.setFileURL(requestFileCenterCreator.getFileURL());
        fileFromCenter.setName(requestFileCenterCreator.getName());
        fileFromCenter.setStatus(1);
        String cdnDomain=projectMapper.getCdn();
        fileFromCenter.setDomain(cdnDomain);
        projectMapper.uploadFileToCenter(fileFromCenter);
        return requestFileCenterCreator.getName();
    }

    @Override
    public void deleteFileFromCenterByToken(Integer userId, Integer fileId) {
        //判断一下用户权限
        //如果这个ID的status是2就执行，如果不是就说明系统漏洞，进行任何操作
        Integer status=projectMapper.findStatusById(userId);
        if (status==2)
        //项目表中删除
        projectMapper.deleteFileFromCenterByToken(fileId);

    }

    @Override
    public void generateForgetCode(Integer userId, String info) {
        //判断一下用户权限
        //如果这个ID的status是2就执行，如果不是就说明系统漏洞，进行任何操作
        Integer status=projectMapper.findStatusById(userId);
        if (status==2)
            //项目表中删除
            projectMapper.generateForgetCode(info);


    }

    @Override
    public void deleteUser(Integer userId, Integer uIdForUser) {
        //这里加一个判断，如果这个ID的status是2就获取全部，如果不是就说明系统漏洞
        Integer status=projectMapper.findStatusById(userId);
        if (status==2) {
            //此功能是移出黑名单的用户，也就是status为4的用户变成3
            projectMapper.deleteUser(uIdForUser);

        }


    }

}
